﻿using System;
using System.Text;
using System.ComponentModel;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Linq;
using PSE.Framework.UI.Resources;
using Sinacor.Infra.UI.Common;
using Sinacor.Infra.Common.Exceptions;
using Sinacor.UI.Bovespa.Ordens;
using Sinacor.UI.Bovespa.Ordens.Model;
using Sinacor.UI.Bovespa.Ordens.Communication;
using Sinacor.UI.Bovespa.Ordens.Model.Parameter;

namespace Sinacor.UI.Bovespa.Ordens.Presenter
{
    public class DistribuicaoOrdemLotePresenter : BasePresenter<IDistribuicaoOrdemLoteView>
    {
        #region Atributos
        private string apelidoValidado;
        private string ativoValidado;
        DateTime dataPregaoValidada = DateTime.MinValue;

        private string nomeLoteResourceString = (string)ResourceProviderManager.GetResourceProvider().TryGetResource("Bovespa.Ordens.Label.NomeLoteField");
        private string nomeNovoLoteResourceString = (string)ResourceProviderManager.GetResourceProvider().TryGetResource("Bovespa.Ordens.Label.NomeNovoLote");

        public Model.Parameter.ConsultarOrdemDistribuicao OrdemDistribuicaoModel { get; set; }
        public Model.Parameter.ConsultarOrdemDistribuicaoOrdem OrdemDistribuicaoOrdemModel { get; set; }

        private ModelCollection<Model.LoteOrdem> _loteVinculadoModelCollectionInicial;
        public ModelCollection<Model.LoteOrdem> LoteVinculadoModelCollectionInicial
        {
            get { return _loteVinculadoModelCollectionInicial; }
            private set
            {
                _loteVinculadoModelCollectionInicial = value;

                if (_loteVinculadoModelCollectionInicial != null)
                {
                    this._loteVinculadoModelCollectionInicial.EnableStateControl = true;
                }
            }
        }

        private ModelCollection<Model.LoteOrdem> _loteVinculadoModelCollection;
        public ModelCollection<Model.LoteOrdem> LoteVinculadoModelCollection
        {
            get { return _loteVinculadoModelCollection; }

            private set
            {
                _loteVinculadoModelCollection = value;

                if (_loteVinculadoModelCollection != null)
                {
                    this._loteVinculadoModelCollection.EnableStateControl = true;
                }
            }
        }

        //TRÊS MODELS NOVAS
        public ModelCollection<Model.LoteOrdem> _precoMedioTodasModelCollection;
        public ModelCollection<Model.LoteOrdem> PrecoMedioTodasModelCollection
        {
            get { return this._precoMedioTodasModelCollection; }

            private set
            {
                this._precoMedioTodasModelCollection = value;

                if (this._precoMedioTodasModelCollection != null)
                {
                    this._precoMedioTodasModelCollection.EnableStateControl = true;
                }
            }
        }

        public ModelCollection<Model.LoteOrdem> _precoMedioDiscricionariasModelCollection;
        public ModelCollection<Model.LoteOrdem> PrecoMedioDiscricionariasModelCollection
        {
            get { return this._precoMedioDiscricionariasModelCollection; }

            private set
            {
                this._precoMedioDiscricionariasModelCollection = value;

                if (this._precoMedioDiscricionariasModelCollection != null)
                {
                    this._precoMedioDiscricionariasModelCollection.EnableStateControl = true;
                }
            }
        }

        public ModelCollection<Model.LoteOrdem> _precoMedioNaoDiscricionariasModelCollection;
        public ModelCollection<Model.LoteOrdem> PrecoMedioNaoDiscricionariasModelCollection
        {
            get { return this._precoMedioNaoDiscricionariasModelCollection; }

            private set
            {
                this._precoMedioNaoDiscricionariasModelCollection = value;

                if (this._precoMedioNaoDiscricionariasModelCollection != null)
                {
                    this._precoMedioNaoDiscricionariasModelCollection.EnableStateControl = true;
                }
            }
        }
        //-----------------

        private ModelCollection<Model.LoteOrdem> _loteVinculadoContextMenuModelCollection;
        public ModelCollection<Model.LoteOrdem> LoteVinculadoContextMenuModelCollection
        {
            get { return _loteVinculadoContextMenuModelCollection; }

            private set
            {
                _loteVinculadoContextMenuModelCollection = value;

                if (_loteVinculadoContextMenuModelCollection != null)
                {
                    this._loteVinculadoContextMenuModelCollection.EnableStateControl = true;
                }
            }
        }

        //TRÊS MODELS NOVAS
        private ModelCollection<Model.LoteOrdem> _trocarLoteBoxTodasModelCollection;
        public ModelCollection<Model.LoteOrdem> TrocarLoteBoxTodasModelCollection
        {
            get { return this._trocarLoteBoxTodasModelCollection; }

            private set
            {
                this._trocarLoteBoxTodasModelCollection = value;

                if (this._trocarLoteBoxTodasModelCollection != null)
                    this._trocarLoteBoxTodasModelCollection.EnableStateControl = true;
            }
        }

        private ModelCollection<Model.LoteOrdem> _trocarLoteBoxDiscricionariasModelCollection;
        public ModelCollection<Model.LoteOrdem> TrocarLoteBoxDiscricionariasModelCollection
        {
            get { return this._trocarLoteBoxDiscricionariasModelCollection; }

            private set
            {
                this._trocarLoteBoxDiscricionariasModelCollection = value;

                if (this._trocarLoteBoxDiscricionariasModelCollection != null)
                    this._trocarLoteBoxDiscricionariasModelCollection.EnableStateControl = true;
            }
        }

        private ModelCollection<Model.LoteOrdem> _trocarLoteBoxNaoDiscricionariasModelCollection;
        public ModelCollection<Model.LoteOrdem> TrocarLoteBoxNaoDiscricionariasModelCollection
        {
            get { return this._trocarLoteBoxNaoDiscricionariasModelCollection; }

            private set
            {
                this._trocarLoteBoxNaoDiscricionariasModelCollection = value;

                if (this._trocarLoteBoxNaoDiscricionariasModelCollection != null)
                    this._trocarLoteBoxNaoDiscricionariasModelCollection.EnableStateControl = true;
            }
        }

        //-----------------

        //MODEL VELHA
        private ModelCollection<Model.Ordem> _ordemDistribuicaoModelCollection;
        public ModelCollection<Model.Ordem> OrdemDistribuicaoModelCollection
        {
            get { return _ordemDistribuicaoModelCollection; }

            private set
            {
                _ordemDistribuicaoModelCollection = value;

                if (_ordemDistribuicaoModelCollection != null)
                {
                    this._ordemDistribuicaoModelCollection.EnableStateControl = true;
                }
            }
        }

        //TRÊS MODELS NOVAS
        private ModelCollection<Model.Ordem> _lotesDiscricionariasModelCollection;
        public ModelCollection<Model.Ordem> LotesDiscricionariasModelCollection
        {
            get { return _lotesDiscricionariasModelCollection; }

            private set
            {
                _lotesDiscricionariasModelCollection = value;

                if (_lotesDiscricionariasModelCollection != null)
                {
                    this._lotesDiscricionariasModelCollection.EnableStateControl = true;
                }
            }
        }

        private ModelCollection<Model.Ordem> _lotesNaoDiscricionariasModelCollection;
        public ModelCollection<Model.Ordem> LotesNaoDiscricionariasModelCollection
        {
            get { return _lotesNaoDiscricionariasModelCollection; }

            private set
            {
                _lotesNaoDiscricionariasModelCollection = value;

                if (_lotesNaoDiscricionariasModelCollection != null)
                {
                    this._lotesNaoDiscricionariasModelCollection.EnableStateControl = true;
                }
            }
        }

        private ModelCollection<Model.Ordem> _lotesTodasModelCollection;
        public ModelCollection<Model.Ordem> LotesTodasModelCollection
        {
            get { return _lotesTodasModelCollection; }

            private set
            {
                _lotesTodasModelCollection = value;

                if (_lotesTodasModelCollection != null)
                {
                    this._lotesTodasModelCollection.EnableStateControl = true;
                }
            }
        }


        private ModelCollection<Model.Ordem> _ordemDistribuicaoOrdemModelCollection;
        public ModelCollection<Model.Ordem> OrdemDistribuicaoOrdemModelCollection
        {
            get { return _ordemDistribuicaoOrdemModelCollection; }

            private set
            {
                _ordemDistribuicaoOrdemModelCollection = value;

                if (_ordemDistribuicaoOrdemModelCollection != null)
                {
                    this._ordemDistribuicaoOrdemModelCollection.EnableStateControl = true;
                }
            }
        }

        private ModelCollection<Model.Ordem> _ordensDiscricionariasModelCollection;
        public ModelCollection<Model.Ordem> OrdensDiscricionariasModelCollection
        {
            get { return _ordensDiscricionariasModelCollection; }

            private set
            {
                _ordensDiscricionariasModelCollection = value;

                if (_ordensDiscricionariasModelCollection != null)
                {
                    this._ordensDiscricionariasModelCollection.EnableStateControl = true;
                }
            }
        }

        private ModelCollection<Model.Ordem> _ordensNaoDiscricionariasModelCollection;
        public ModelCollection<Model.Ordem> OrdensNaoDiscricionariasModelCollection
        {
            get { return _ordensNaoDiscricionariasModelCollection; }

            private set
            {
                _ordensNaoDiscricionariasModelCollection = value;

                if (_ordensNaoDiscricionariasModelCollection != null)
                {
                    this._ordensNaoDiscricionariasModelCollection.EnableStateControl = true;
                }
            }
        }

        private ModelCollection<Model.Ordem> _ordemTodasModelCollection;
        public ModelCollection<Model.Ordem> OrdensTodasModelCollection
        {
            get { return _ordemTodasModelCollection; }

            private set
            {
                _ordemTodasModelCollection = value;

                if (_ordemTodasModelCollection != null)
                {
                    this._ordemTodasModelCollection.EnableStateControl = true;
                }
            }
        }

        private ModelCollection<Model.Calendario> _modelCalendario;
        public ModelCollection<Model.Calendario> CalendarioModelCollection
        {
            get { return _modelCalendario; }

            private set
            {
                _modelCalendario = value;

                if (_modelCalendario != null)
                {
                    this.CalendarioModelCollection.EnableStateControl = true;
                }
            }
        }

        private Model.DistribuicaoOrdensLoteControles _distribuicaoControles = new DistribuicaoOrdensLoteControles();
        public Model.DistribuicaoOrdensLoteControles DistribuicaoControles
        {
            get { return this._distribuicaoControles; }
            set { this._distribuicaoControles = value; }
        }
        #endregion Atributos

        public int CriarLoteOrdem(ModelCollection<Model.Ordem> ordemModelCollection)
        {
            int resultado = 0;

            try
            {
                // // View.Habilitar(false);
                ModelCollection<Model.LoteOrdem> loteOrdemModelCollection = new ModelCollection<Model.LoteOrdem>();
                Communication.Translator.TranslateLoteOrdem xl = new Communication.Translator.TranslateLoteOrdem();

                foreach (Model.Ordem ordem in ordemModelCollection)
                {
                    loteOrdemModelCollection.Add(xl.ToLoteOrdem(ordem));
                }

                resultado = (new Communication.LoteOrdem(this.Session)).CriarLoteOrdem(loteOrdemModelCollection);
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }
            finally
            {
                if (resultado == 0)
                    AtualizarView(string.Empty);
            }

            return resultado;
        }

        private void AtualizarView(string messageResourceString)
        {
            View.ApresentarOrdemDistribuicaoOrdem();
            View.ApresentarLoteVinculado();
            View.ApresentarLoteVinculadoContextMenu();

            if (!String.IsNullOrEmpty(messageResourceString))
                View.Informar(messageResourceString);

            View.Habilitar(true);
        }

        public bool TrocarLoteOrdem(ModelCollection<Model.Ordem> ordemModelCollection, int numeroLoteDestino)
        {
            bool resultado = false;

            try
            {
                // View.Habilitar(false);
                Communication.Translator.TranslateLoteOrdem xl = new Communication.Translator.TranslateLoteOrdem();
                ModelCollection<Model.LoteOrdem> loteOrdemModelCollection = xl.ToLoteOrdemModelCollection(ordemModelCollection, numeroLoteDestino);
                resultado = (new Communication.LoteOrdem(this.Session)).TrocarLoteOrdem(loteOrdemModelCollection);
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }

            return resultado;
        }

        /// <summary>
        /// Carrega o combo Data
        /// </summary>
        public void ConsultarCalendario()
        {
            try
            {
                // View.Habilitar(false);
                this.CalendarioModelCollection = (new Communication.Calendario(this.Session)).ConsultarCalendario();

                
            }
            catch (Exception ex)
            {
                View.Habilitar(true);
                HandleException(ex);
            }

            View.ApresentarDataCalendario();
        }

        /// <summary>
        /// Carrega o grid de Lotes
        /// </summary>
        public void ConsultarOrdemDistribuicao(
            Model.Parameter.ConsultarOrdemDistribuicao ordemDistribuicaoParameter,
            string codigoAtivo,
            string apelidoCliente
        )
        {
            try
            {
                // View.Habilitar(false);
                ReiniciarAtributosLote();

                if (!CampoAtivoValido(codigoAtivo, ordemDistribuicaoParameter.DataPregao))
                {
                    View.InformarErro("Bovespa.Ordens.Message.AtivoInexistente");
                    return;
                }

                if (!CampoApelidoValido(apelidoCliente))
                {
                    View.InformarErro("Bovespa.Ordens.Message.ClienteInexistente");
                    return;
                }

                //OrdemDistribuicaoModelCollection = (new Communication.Ordem(this.Session)).ConsultarOrdemDistribuicao(ordemDistribuicaoParameter);

                //if (OrdemDistribuicaoModelCollection == null || OrdemDistribuicaoModelCollection.Count == 0)
                //    View.InformarErro("Bovespa.Ordens.Message.PesquisaSemRetorno");

                LotesTodasModelCollection = (new Communication.Ordem(this.Session)).ConsultarOrdemDistribuicao(ordemDistribuicaoParameter);

                if (LotesTodasModelCollection != null && LotesTodasModelCollection.Count > 0)
                {
                    //Reinicializo as modelcollections discricionárias/não discricionárias
                    LotesDiscricionariasModelCollection = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem>();
                    LotesNaoDiscricionariasModelCollection = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem>();

                    //Se o código chegou até aqui, então a model está preenchida, vou distribuir as discricionárias/não discricionárias
                    foreach (Model.Ordem itemLote in LotesTodasModelCollection)
                    {
                        if (itemLote.Discricionaria == "S")
                            LotesDiscricionariasModelCollection.Add(itemLote);
                        else
                            LotesNaoDiscricionariasModelCollection.Add(itemLote);
                    }

                    LotesTodasModelCollection.SaveAll();
                    LotesDiscricionariasModelCollection.SaveAll();
                    LotesNaoDiscricionariasModelCollection.SaveAll();
                }


            }
            catch (TimeoutException)
            {
                View.InformarErro("Bovespa.Ordens.ExceptionMessage.TimeOutServico");
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }
            finally
            {
                View.Habilitar(true);
            }

            View.ApresentarOrdemDistribuicao();
            View.ApresentarOrdemDistribuicaoOrdem();
            View.ApresentarLoteVinculado();
            View.ApresentarLoteVinculadoContextMenu();
        }


        private void ConsultarOrdemDistribuicaoOrdem(
            Model.Ordem ordem,
            Model.Calendario cal,
            Model.Parameter.TipoAgrupamentoLote tipoAgrupamento,
            bool? consultaDiscricionaria)
        {
            try
            {
                // View.Habilitar(false);
                Communication.Ordem servico = new Communication.Ordem(this.Session);
                Model.Enum.TipoOrdemDistribuicao enumTipoOrdemDistribuicao;
                enumTipoOrdemDistribuicao = View.VerificarTipoOrdemDistribuicao();

                if (ordem.NumeroConjunto == null || ordem.NumeroConjunto == 0)
                {
                    // executa o servico correspondente ao tipo de agrupamento desejado
                    switch (tipoAgrupamento)
                    {
                        case TipoAgrupamentoLote.Operador:
                            Model.Parameter.ConsultarOrdemDistribuicaoOrdemOperador consultaOperador = new ConsultarOrdemDistribuicaoOrdemOperador();

                            consultaOperador.ApelidoCliente = ordem.ApelidoCliente;
                            consultaOperador.CodigoBolsa = ordem.Bolsa;
                            consultaOperador.CodigoNegocio = ordem.Titulo;
                            consultaOperador.DataPregao = cal.DataPregao;
                            //consultaOperador.IsDiscricionaria = consultaDiscricionaria;
                            consultaOperador.IsDiscricionaria = ordem.Discricionaria == "N" ? false : true;
                            consultaOperador.LoginOperador = ordem.LoginOperador;
                            consultaOperador.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)ordem.NaturezaOperacao;
                            consultaOperador.PrazoTermo = ordem.PrazoTermo;

                            OrdemDistribuicaoOrdemModelCollection = servico.ConsultarOrdemDistribuicaoOrdemOperador(consultaOperador);
                            break;

                        case TipoAgrupamentoLote.SemAgrupamento:
                            Model.Parameter.ConsultarOrdemDistribuicaoOrdem consultaOrdem = new ConsultarOrdemDistribuicaoOrdem();

                            consultaOrdem.ApelidoCliente = ordem.ApelidoCliente;
                            consultaOrdem.CodigoBolsa = ordem.Bolsa;
                            consultaOrdem.CodigoNegocio = ordem.Titulo;
                            consultaOrdem.DataPregao = cal.DataPregao;
                            consultaOrdem.IsDiscricionaria = ordem.Discricionaria == "N" ? false : true;
                            consultaOrdem.DataOrdem = ordem.DataOrdem;
                            consultaOrdem.NumeroOrdem = ordem.NumeroOrdem;
                            consultaOrdem.NumeroSubSequencia = ordem.NumeroOrdemSequencia;
                            consultaOrdem.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)ordem.NaturezaOperacao;
                            consultaOrdem.PrazoTermo = ordem.PrazoTermo;

                            OrdemDistribuicaoOrdemModelCollection = servico.ConsultarOrdemDistribuicaoOrdem(consultaOrdem);
                            break;

                        default:
                            Model.Parameter.ConsultarOrdemDistribuicaoOrdemPadrao consultaPadrao = new ConsultarOrdemDistribuicaoOrdemPadrao();

                            consultaPadrao.ApelidoCliente = ordem.ApelidoCliente;
                            consultaPadrao.CodigoBolsa = ordem.Bolsa;
                            consultaPadrao.CodigoNegocio = ordem.Titulo;
                            consultaPadrao.DataPregao = cal.DataPregao;
                            //consultaPadrao.IsDiscricionaria = consultaDiscricionaria;
                            consultaPadrao.IsDiscricionaria = ordem.Discricionaria == "N" ? false : true;
                            consultaPadrao.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)ordem.NaturezaOperacao;
                            consultaPadrao.NumeroConjunto = ordem.NumeroConjunto;
                            consultaPadrao.PrazoTermo = ordem.PrazoTermo;

                            OrdemDistribuicaoOrdemModelCollection = servico.ConsultarOrdemDistribuicaoOrdemPadrao(consultaPadrao);
                            break;
                    }
                }
                else
                {
                    Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote consultaLote = new ConsultarOrdemDistribuicaoOrdemLote();
                    consultaLote.NumeroConjunto = ordem.NumeroConjunto.Value;

                    List<Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote> lista = new List<ConsultarOrdemDistribuicaoOrdemLote>();
                    lista.Add(consultaLote);
                    OrdemDistribuicaoOrdemModelCollection = (new Communication.Ordem(this.Session)).ConsultarOrdemDistribuicaoOrdemLote(lista);
                }

                if (OrdemDistribuicaoOrdemModelCollection != null)
                {
                    Model.Parameter.ConsultarLoteVinculado consultaLoteVinculado = new ConsultarLoteVinculado();

                    consultaLoteVinculado.ApelidoCliente = ordem.ApelidoCliente;
                    consultaLoteVinculado.CodigoCasamento = ordem.CodigoCasamento;
                    consultaLoteVinculado.CodigoCliente = null;
                    consultaLoteVinculado.CodigoNegocio = ordem.Titulo;
                    consultaLoteVinculado.DataPregao = cal.DataPregao;
                    consultaLoteVinculado.Discricionaria = ordem.Discricionaria;
                    consultaLoteVinculado.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)ordem.NaturezaOperacao;
                    consultaLoteVinculado.NumeroConjunto = ordem.NumeroConjunto.Value;
                    consultaLoteVinculado.PrazoTermo = ordem.PrazoTermo;

                    //VOU PASSAR ESSE CARA PRA CHAMADA ESPECÍFICA
                    ConsultarLoteVinculado(consultaLoteVinculado);

                    // TO DO:
                    // work-around:
                    // preencher o resto dos dados que vem vazios na model
                    foreach (Model.Ordem o in OrdemDistribuicaoOrdemModelCollection)
                    {
                        o.DataPregao = cal.DataPregao;
                        o.NumeroConjunto = ordem.NumeroConjunto;
                        o.TipoOrdemDistribuicao = enumTipoOrdemDistribuicao;
                    }
                }



            }
            catch (BusinessException ex)
            {
                if (ex.ErrorNumber == 0)
                {
                    LoteVinculadoModelCollection = null;
                    LoteVinculadoContextMenuModelCollection = null;
                }
                else
                    throw ex;
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }

        }

        public void ConsultarOrdensDistribuicaoTodas(
            Model.Ordem ordem,
            Model.Calendario cal,
            Model.Parameter.TipoAgrupamentoLote tipoAgrupamento,
            bool? consultaDiscricionaria)
        {
            //CONSULTO AS ORDENS
            ConsultarOrdemDistribuicaoOrdem(ordem, cal, tipoAgrupamento, consultaDiscricionaria);

            //ATRIBUO OS RESULTADOS DA CONSULTA ÀS MODELS CORRETAS
            OrdensTodasModelCollection = OrdemDistribuicaoOrdemModelCollection;
            PrecoMedioTodasModelCollection = LoteVinculadoModelCollection;
            TrocarLoteBoxTodasModelCollection = LoteVinculadoContextMenuModelCollection;

            //ATUALIZO A VIEW
            AtualizarView(null);

            View.ApresentarMensagemOrdem(OrdensTodasModelCollection.Count(ordems => !ordem.QuantidadeCasada.HasValue || ordems.QuantidadeCasada.Value == 0) > 0);
        }

        public void ConsultarOrdensDistribuicaoDiscricionarias(
            Model.Ordem ordem,
            Model.Calendario cal,
            Model.Parameter.TipoAgrupamentoLote tipoAgrupamento,
            bool? consultaDiscricionaria)
        {
            //CONSULTO AS ORDENS
            ConsultarOrdemDistribuicaoOrdem(ordem, cal, tipoAgrupamento, consultaDiscricionaria);

            //ATRIBUO OS RESULTADOS DA CONSULTA ÀS MODELS CORRETAS
            OrdensDiscricionariasModelCollection = OrdemDistribuicaoOrdemModelCollection;
            PrecoMedioDiscricionariasModelCollection = LoteVinculadoModelCollection;
            TrocarLoteBoxDiscricionariasModelCollection = LoteVinculadoContextMenuModelCollection;

            //ATUALIZO A VIEW
            AtualizarView(null);

            View.ApresentarMensagemOrdem(OrdensDiscricionariasModelCollection.Count(ordems => !ordem.QuantidadeCasada.HasValue || ordems.QuantidadeCasada.Value == 0) > 0);
        }

        public void ConsultarOrdensDistribuicaoNaoDiscricionarias(
            Model.Ordem ordem,
            Model.Calendario cal,
            Model.Parameter.TipoAgrupamentoLote tipoAgrupamento,
            bool? consultaDiscricionaria)
        {
            //CONSULTO AS ORDENS
            ConsultarOrdemDistribuicaoOrdem(ordem, cal, tipoAgrupamento, consultaDiscricionaria);

            //ATRIBUO OS RESULTADOS DA CONSULTA ÀS MODELS CORRETAS
            OrdensNaoDiscricionariasModelCollection = OrdemDistribuicaoOrdemModelCollection;
            PrecoMedioNaoDiscricionariasModelCollection = LoteVinculadoModelCollection;
            TrocarLoteBoxNaoDiscricionariasModelCollection = LoteVinculadoContextMenuModelCollection;

            //ATUALIZO A VIEW
            AtualizarView(null);

            View.ApresentarMensagemOrdem(OrdensNaoDiscricionariasModelCollection.Count(ordems => !ordem.QuantidadeCasada.HasValue || ordems.QuantidadeCasada.Value == 0) > 0);
        }

        /// <summary>
        /// Recebe um lote e retor as ordens
        /// </summary>
        public ModelCollection<Model.Ordem> ConsultarOrdensLote(Model.Ordem ordem, Model.Calendario cal, Model.Parameter.TipoAgrupamentoLote tipoAgrupamento, bool? consultaDiscricionaria)
        {

            ModelCollection<Model.Ordem> retorno = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem>();
            Communication.Ordem servico = new Communication.Ordem(this.Session);
            Model.Enum.TipoOrdemDistribuicao enumTipoOrdemDistribuicao;
            enumTipoOrdemDistribuicao = View.VerificarTipoOrdemDistribuicao();

            try
            {
                switch (tipoAgrupamento)
                {
                    case TipoAgrupamentoLote.Operador:
                        Model.Parameter.ConsultarOrdemDistribuicaoOrdemOperador consultaOperador = new ConsultarOrdemDistribuicaoOrdemOperador();

                        consultaOperador.ApelidoCliente = ordem.ApelidoCliente;
                        consultaOperador.CodigoBolsa = ordem.Bolsa;
                        consultaOperador.CodigoNegocio = ordem.Titulo;
                        consultaOperador.DataPregao = cal.DataPregao;
                        consultaOperador.IsDiscricionaria = consultaDiscricionaria;
                        consultaOperador.LoginOperador = ordem.LoginOperador;
                        consultaOperador.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)ordem.NaturezaOperacao;
                        consultaOperador.PrazoTermo = ordem.PrazoTermo;

                        retorno = servico.ConsultarOrdemDistribuicaoOrdemOperador(consultaOperador);
                        break;

                    case TipoAgrupamentoLote.SemAgrupamento:
                        Model.Parameter.ConsultarOrdemDistribuicaoOrdem consultaOrdem = new ConsultarOrdemDistribuicaoOrdem();

                        consultaOrdem.ApelidoCliente = ordem.ApelidoCliente;
                        consultaOrdem.CodigoBolsa = ordem.Bolsa;
                        consultaOrdem.CodigoNegocio = ordem.Titulo;
                        consultaOrdem.DataPregao = cal.DataPregao;
                        consultaOrdem.IsDiscricionaria = consultaDiscricionaria;
                        consultaOrdem.DataOrdem = ordem.DataOrdem;
                        consultaOrdem.NumeroOrdem = ordem.NumeroOrdem;
                        consultaOrdem.NumeroSubSequencia = ordem.NumeroOrdemSequencia;
                        consultaOrdem.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)ordem.NaturezaOperacao;
                        consultaOrdem.PrazoTermo = ordem.PrazoTermo;

                        retorno = servico.ConsultarOrdemDistribuicaoOrdem(consultaOrdem);
                        break;

                    default:
                        Model.Parameter.ConsultarOrdemDistribuicaoOrdemPadrao consultaPadrao = new ConsultarOrdemDistribuicaoOrdemPadrao();

                        consultaPadrao.ApelidoCliente = ordem.ApelidoCliente;
                        consultaPadrao.CodigoBolsa = ordem.Bolsa;
                        consultaPadrao.CodigoNegocio = ordem.Titulo;
                        consultaPadrao.DataPregao = cal.DataPregao;
                        consultaPadrao.IsDiscricionaria = consultaDiscricionaria;
                        consultaPadrao.NaturezaOperacao = (Model.Enum.TipoNaturezaOperacao?)ordem.NaturezaOperacao;
                        consultaPadrao.NumeroConjunto = ordem.NumeroConjunto;
                        consultaPadrao.PrazoTermo = ordem.PrazoTermo;

                        retorno = servico.ConsultarOrdemDistribuicaoOrdemPadrao(consultaPadrao);
                        break;
                }

                // work-around:
                // preencher o resto dos dados que vem vazios na model
                foreach (Model.Ordem o in retorno)
                {
                    o.DataPregao = cal.DataPregao;
                    o.NumeroConjunto = ordem.NumeroConjunto;
                    o.TipoOrdemDistribuicao = enumTipoOrdemDistribuicao;
                }
            }
            catch (Exception ex)
            {
                HandleException(ex);
            }

            return retorno;
        }

        private void ConsultarLoteVinculado(Model.Parameter.ConsultarLoteVinculado loteVinculado)
        {
            Model.LoteOrdem loteAtual = null;
            LoteVinculadoModelCollection = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.LoteOrdem>();
            LoteVinculadoContextMenuModelCollection = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.LoteOrdem>();
            ModelCollection<Model.LoteOrdem> lotes = (new Communication.LoteOrdem(this.Session)).ConsultarLoteVinculado(loteVinculado);

            // se numero do lote e´ ZERO, nao e´ lote. nao existira´ o item que informa o preco medio do lote atual.
            if (loteVinculado.NumeroConjunto != 0)
            {
                // remover lote atualmente selecionado da lista para reposiciona-lo em primeiro lugar.
                foreach (Model.LoteOrdem lo in lotes)
                {
                    if (lo.NumeroConjunto != 0 && lo.NumeroConjunto == loteVinculado.NumeroConjunto)
                    {
                        lo.NomeLote = string.Format(nomeLoteResourceString, lo.NumeroConjunto);
                        loteAtual = lo;
                        lotes.Remove(lo);
                        break;
                    }
                }

                // se lote atual nao foi encontrado na lista, criar um lote com as caracteristicas esperadas
                if (loteAtual == null)
                    loteAtual = new Sinacor.UI.Bovespa.Ordens.Model.LoteOrdem()
                    {
                        DataPregao = (DateTime)loteVinculado.DataPregao,
                        NumeroConjunto = (int)loteVinculado.NumeroConjunto,
                        NomeLote = string.Format(nomeLoteResourceString, loteVinculado.NumeroConjunto),
                        PrecoMedio = 0
                    };

                // adicionar lote atual na cabeca da lista
                LoteVinculadoModelCollection.Add(loteAtual);
            }

            // adicionar um item vazio para calculo de preco medio de novo lote
            LoteVinculadoModelCollection.Add(
                new Sinacor.UI.Bovespa.Ordens.Model.LoteOrdem()
                {
                    NumeroConjunto = 0,
                    NomeLote = nomeNovoLoteResourceString,
                    PrecoMedio = 0
                }
            );

            // adicionar os lotes restantes `a lista
            foreach (Model.LoteOrdem loRestante in lotes)
            {
                loRestante.NomeLote = string.Format(nomeLoteResourceString, loRestante.NumeroConjunto);
                LoteVinculadoContextMenuModelCollection.Add(loRestante);
                LoteVinculadoModelCollection.Add(loRestante);
            }

            // eliminar estado de "alterado" das collections
            LoteVinculadoModelCollection.SaveAll();
            LoteVinculadoContextMenuModelCollection.SaveAll();
        }

        public void ConsultarLoteVinculadoDiscricionarias(Model.Parameter.ConsultarLoteVinculado loteVinculado)
        {
            ConsultarLoteVinculado(loteVinculado);
            PrecoMedioDiscricionariasModelCollection = LoteVinculadoModelCollection;
        }

        public void ConsultarLoteVinculadoNaoDiscricionarias(Model.Parameter.ConsultarLoteVinculado loteVinculado)
        {
            ConsultarLoteVinculado(loteVinculado);
            PrecoMedioNaoDiscricionariasModelCollection = LoteVinculadoModelCollection;
        }

        public void ConsultarLoteVinculadoTodas(Model.Parameter.ConsultarLoteVinculado loteVinculado)
        {
            ConsultarLoteVinculado(loteVinculado);
            PrecoMedioTodasModelCollection = LoteVinculadoModelCollection;
        }

        public void Inicializar()
        {
            this.ConsultarCalendario();
        }

        public void Limpar()
        {
            this.ReiniciarTodosAtributos();

            View.ApresentarOrdemDistribuicao();
            View.ApresentarOrdemDistribuicaoOrdem();
            View.ApresentarLoteVinculado();
            View.ApresentarLoteVinculadoContextMenu();
            View.ApresentarDataCalendario();
        }

        private void ReiniciarTodosAtributos()
        {
            ReiniciarAtributosLote();
            //Esta linha abaixo vai sair
            OrdemDistribuicaoModelCollection = null;

            LotesTodasModelCollection = null;
            LotesDiscricionariasModelCollection = null;
            LotesNaoDiscricionariasModelCollection = null;

            OrdensDiscricionariasModelCollection = null;
            OrdensNaoDiscricionariasModelCollection = null;
            OrdensTodasModelCollection = null;

            PrecoMedioDiscricionariasModelCollection = null;
            PrecoMedioNaoDiscricionariasModelCollection = null;
            PrecoMedioTodasModelCollection = null;

            TrocarLoteBoxDiscricionariasModelCollection = null;
            TrocarLoteBoxNaoDiscricionariasModelCollection = null;
            TrocarLoteBoxTodasModelCollection = null;
        }

        private void ReiniciarAtributosLote()
        {
            OrdemDistribuicaoOrdemModelCollection = null;
            LoteVinculadoModelCollection = null;
            LoteVinculadoContextMenuModelCollection = null;

            OrdensTodasModelCollection = null;
            OrdensDiscricionariasModelCollection = null;
            OrdensNaoDiscricionariasModelCollection = null;

            //AS MODELCOLLECTIONS ABAIXO SUBSTITUEM A LoteVinculadoContextMenuModelCollection NA TRIPLICAÇÃO DA TELA.
            TrocarLoteBoxDiscricionariasModelCollection = null;
            TrocarLoteBoxNaoDiscricionariasModelCollection = null;
            TrocarLoteBoxTodasModelCollection = null;
        }

        public DistribuicaoOrdemLotePresenter(IDistribuicaoOrdemLoteView view)
            : base(view)
        {
            OrdemDistribuicaoModel = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemDistribuicao();
            OrdemDistribuicaoOrdemModel = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemDistribuicaoOrdem();
        }


        /// <summary>
        /// Calcula o preço médio de uma lista de ordens.
        /// </summary>
        /// <param name="ordemModelCollection"></param>
        /// <returns>O preço médio correto ou ZERO se o total da quantidade casada for zero.</returns>
        public decimal CalcularPrecoMedio(List<Model.Ordem> ordemList)
        {
            decimal volume = 0;
            decimal qtdTotal = 0;

            foreach (Model.Ordem ordem in ordemList)
            {
                if (ordem.PrecoMedio != null && ordem.QuantidadeCasada != null)
                {
                    volume += ordem.PrecoMedio.Value * ordem.QuantidadeCasada.Value;
                    qtdTotal += ordem.QuantidadeCasada.Value;
                }
            }

            return qtdTotal != 0 ? Math.Round(volume / qtdTotal, 6) : 0;
        }

        /// <summary>
        /// Calcula o preço médio de uma lista de 'Model.Ordem'.
        /// </summary>
        /// <param name="iList"></param>
        /// <returns></returns>
        public decimal CalcularPrecoMedio(System.Collections.IList iList)
        {
            List<Model.Ordem> ordemList = new List<Sinacor.UI.Bovespa.Ordens.Model.Ordem>();

            foreach (Model.Ordem ordem in iList)
            {
                ordemList.Add(ordem);
            }

            return CalcularPrecoMedio(ordemList);
        }

        /// <summary>
        /// Verifica se um cliente existe dado o apelido do mesmo.
        /// </summary>
        /// <param name="apelidoCliente"></param>
        /// <returns></returns>
        public bool ValidarExistenciaCliente(string apelidoCliente)
        {
            try
            {
                ConsultarClienteApelidoRequest apelidoRequest = new ConsultarClienteApelidoRequest();
                apelidoRequest.Apelido = apelidoCliente;
                Model.Cliente cliente = new Communication.Cliente(this.Session).ConsultarClienteApelido(apelidoRequest);

                //O MÉTODO ACIMA GERA UMA BUSINESSEXCEPTION CASO O CLIENTE NÃO SEJA ENCONTRADO.
                //PORTANTO CASO A EXECUÇÃO ATINJA ESTE PONTO, ELE FOI ENCONTRADO. SÓ INTERESSA AGORA
                //SABER SE O CLIENTE ESTÁ BLOQUEADO
                return !cliente.isBloqueado;
            }
            catch (BusinessException ex)
            {
                if (ex.ErrorNumber == 105000)
                    return false;
                else
                    throw ex;
            }
            catch (Exception ex)
            {
                HandleException(ex);
                return false;
            }
        }

        /// <summary>
        /// Verifica se um determinado ativo existe.
        /// </summary>
        /// <param name="tituloReq"></param>
        /// <returns></returns>
        public bool ValidarExistenciaAtivo(Model.Titulo tituloReq)
        {
            try
            {
                Communication.Titulo servico = new Sinacor.UI.Bovespa.Ordens.Communication.Titulo(this.Session);
                Model.Titulo titulo = servico.ConsultarTituloCodigo(tituloReq);
                return titulo != null && titulo.Codigo == tituloReq.Codigo;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Confirma validade de texto existente em campo da View que contenha o código do ativo.
        /// CARACTERÍSTICA DESATIVADA: Se o campo for válido, guarda o valor para evitar verificações redundantes na UI.
        /// </summary>
        /// <param name="codigoAtivo"></param>
        /// <param name="dataPregao"></param>
        /// <returns></returns>
        public bool CampoAtivoValido(string codigoAtivo, DateTime dataPregao)
        {
            // conteudo vazio ou igual `a ultima validacao sera´ considerado valido.            
            // if (String.IsNullOrEmpty(codigoAtivo) || (ativoValidado == codigoAtivo && dataPregao == dataPregaoValidada))
            if (String.IsNullOrEmpty(codigoAtivo))
                return true;

            // se campo nao esta´ vazio, valida informacao no servico.
            Model.Titulo titulo = new Model.Titulo() { Codigo = codigoAtivo, DataPregao = dataPregao };

            if (ValidarExistenciaAtivo(titulo))
            {
                ativoValidado = codigoAtivo;
                dataPregaoValidada = dataPregao;
                return true;
            }

            // campo invalido: limpa informacoes.
            ativoValidado = string.Empty;
            dataPregaoValidada = DateTime.MinValue;
            return false;
        }

        /// <summary>
        /// Confirma validade de texto existente em campo da View que contenha o apelido do cliente.
        /// CARACTERÍSTICA DESATIVADA: Se o campo for válido, guarda o valor para evitar verificações redundantes na UI.
        /// </summary>
        /// <param name="apelidoCliente"></param>
        /// <returns></returns>
        public bool CampoApelidoValido(string apelidoCliente)
        {
            // conteudo vazio ou igual `a ultima validacao sera´ considerado valido.            
            // if (String.IsNullOrEmpty(apelidoCliente) || apelidoCliente == apelidoValidado)
            if (String.IsNullOrEmpty(apelidoCliente))
                return true;

            // se campo nao esta´ vazio, valida informacao no servico.
            if (ValidarExistenciaCliente(apelidoCliente))
            {
                // guarda ultimo valor validado
                apelidoValidado = apelidoCliente;
                return true;
            }

            // campo invalido: limpa informacoes.
            apelidoValidado = string.Empty;
            return false;
        }

        public Model.Enum.StatusDistribuicaoOrdem VerificarDistribuicaoOrdem(Model.Ordem ordem)
        {
            decimal pctDigitado = ordem.PercentualDigitado == null ? 0 : (decimal)ordem.PercentualDigitado;
            decimal qtdDigitada = ordem.QuantidadeDigitada == null ? 0 : (decimal)ordem.QuantidadeDigitada;
            decimal qtdCasada = ordem.QuantidadeCasada == null ? 0 : (decimal)ordem.QuantidadeCasada;

            if (pctDigitado != 0)
            {
                if (pctDigitado == 100)
                    return Model.Enum.StatusDistribuicaoOrdem.Distribuida;
                else if (pctDigitado > 0 && pctDigitado < 100)
                    return Model.Enum.StatusDistribuicaoOrdem.ParcialmenteDistribuida;

            }

            if (qtdDigitada == 0)
                return Model.Enum.StatusDistribuicaoOrdem.NaoDistribuida;
            else if (qtdCasada == qtdDigitada)
                return Model.Enum.StatusDistribuicaoOrdem.Distribuida;

            // else if (qtdDigitada > 0 && qtdDigitada < qtdCasada)
            return Model.Enum.StatusDistribuicaoOrdem.ParcialmenteDistribuida;
        }

        public void HabilitaControlesConsulta()
        {
            Communication.Acesso ObjAcesso = new Acesso(this.Session);
            Model.Parameter.VeririfcarAcessoFuncao ObjRequest = new VeririfcarAcessoFuncao();

            //ObjRequest.Funcao = "DIST";
            //if (ObjAcesso.ValidarAcessoFuncao(ObjRequest))
            //    View.HabilitarControlesConsulta("DIST");

            ObjRequest.Funcao = "DISL";
            if (!ObjAcesso.ValidarAcessoFuncao(ObjRequest))
                View.InformaUsuarioNaoPermissao();
        }

        public void ValidaDataAgrupamento()
        {
            View.ConfirmarAlteracaoDataPregao();
        }

        public void HabilitaCancelamentoMultiplo(bool Habilitado)
        {
            this._distribuicaoControles.CancelamentoValido = Habilitado;
        }

        public void HabilitarDistribuicao(bool Habilitado)
        {
            this._distribuicaoControles.DistribuicaoValida = Habilitado;
        }

        public void CancelarOrdemDistribuida(Model.Parameter.TipoAgrupamentoLote tipoAgrupamento, bool discricionaria, ModelCollection<Model.Ordem> lotes, DateTime DataPregao)
        {
            //LISTA DE ORDENS CUJA DISTRIBUIÇÃO DEVE SER CANCELADA
            Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote consultaLote = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote();
            //LISTA DE LOTES PARA CONSULTA DE ORDENS
            List<Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote> lista = new List<Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote>();
            //MODELCOLLECTION DE REQUEST DE CANCELAMENTO DE ORDEM
            ModelCollection<Model.Parameter.CancelarOrdemDistribuidaRequest> parameters = new ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Parameter.CancelarOrdemDistribuidaRequest>();

            //PERCORRO A LISTA DE LOTES
            foreach (Model.Ordem lote in lotes)
            {
                lista.Clear();
                //ARMAZENO O NÚMERO DE CADA LOTE NA LISTA DE CONSULTA.                
                consultaLote.NumeroConjunto = lote.NumeroConjunto.Value;
                lista.Add(consultaLote);

                //PREENCHO A LISTA DE ORDENS A CANCELAR DISTRIBUIÇÃO
                ModelCollection<Model.Ordem> ordensCancelamento = (new Communication.Ordem(this.Session)).ConsultarOrdemDistribuicaoOrdemLote(lista);

                foreach (Model.Ordem ordem in ordensCancelamento)
                {
                    Model.Parameter.CancelarOrdemDistribuidaRequest pCancelarOrdemDistribuida = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.CancelarOrdemDistribuidaRequest();

                    //TODO: Confirmar a questão do filhote
                    pCancelarOrdemDistribuida.CodigoFilhote = 0;
                    pCancelarOrdemDistribuida.DataOrdem = (DateTime)ordem.DataOrdem;
                    //pCancelarOrdemDistribuida.DataPregao = (DateTime)ordem.DataPregao; //TODO: CONFIRMAR SE POSSO PASSAR A DATA PREGAO POR PARAMETRO
                    pCancelarOrdemDistribuida.DataPregao = DataPregao;
                    pCancelarOrdemDistribuida.NumeroConjunto = (int)lote.NumeroConjunto;
                    pCancelarOrdemDistribuida.NumeroOrdem = (int)ordem.NumeroOrdem;
                    pCancelarOrdemDistribuida.NumeroOrdemSubSequencia = ordem.NumeroOrdemSubSequencia;
                    pCancelarOrdemDistribuida.TipoCancelamento = "T";

                    parameters.Add(pCancelarOrdemDistribuida);
                }
            }

            //PREENCHO A LISTA DE ORDENS A CANCELAR DISTRIBUIÇÃO
            //ModelCollection<Model.Ordem> ordensCancelamento = (new Communication.Ordem(this.Session)).ConsultarOrdemDistribuicaoOrdemLote(lista);

            //foreach (Model.Ordem ordem in ordensCancelamento)
            //{
            //    Model.Parameter.CancelarOrdemDistribuidaRequest pCancelarOrdemDistribuida = new Sinacor.UI.Bovespa.Ordens.Model.Parameter.CancelarOrdemDistribuidaRequest();

            //    //TODO: Confirmar a questão do filhote
            //    pCancelarOrdemDistribuida.CodigoFilhote = 0;
            //    pCancelarOrdemDistribuida.DataOrdem = (DateTime)ordem.DataOrdem;
            //    //pCancelarOrdemDistribuida.DataPregao = (DateTime)ordem.DataPregao; //TODO: CONFIRMAR SE POSSO PASSAR A DATA PREGAO POR PARAMETRO
            //    pCancelarOrdemDistribuida.DataPregao = DataPregao;
            //    pCancelarOrdemDistribuida.NumeroConjunto = (int)ordem.NumeroConjunto;
            //    pCancelarOrdemDistribuida.NumeroOrdem = (int)ordem.NumeroOrdem;
            //    pCancelarOrdemDistribuida.NumeroOrdemSubSequencia = ordem.NumeroOrdemSubSequencia;
            //    pCancelarOrdemDistribuida.TipoCancelamento = "T";

            //    parameters.Add(pCancelarOrdemDistribuida);
            //}

            if (parameters.Count == 0)
            {
                View.InformarErro("Bovespa.Ordens.Label.ErroRecOrdDistribuicao");
            }
            else
            {
                try
                {
                    View.Habilitar(false);
                    (new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session)).CancelarOrdemDistribuida(parameters);
                    View.Informar("Bovespa.Ordens.Message.CancelamentoOrdemDistSucess");
                }
                catch (Exception ex)
                {
                    base.HandleException(ex);
                }
                finally
                {
                    View.Habilitar(true);
                }
            }
        }

        public void CancelarOrdemDistribuida(ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Parameter.CancelarOrdemDistribuidaRequest> pCancelar)
        {
            try
            {
                View.Habilitar(false);
                (new Sinacor.UI.Bovespa.Ordens.Communication.Ordem(this.Session)).CancelarOrdemDistribuida(pCancelar);
                View.Habilitar(true);
                View.InformarCancelamentoEfetuado();
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
            }
            finally
            {
                View.Habilitar(false);
                View.AtualizaGrids(true);
                View.Habilitar(true);
            }
        }

        public bool VerificaPermissaoUsuario(Model.Parameter.VerificarAcessoFuncaoRequest objRequest)
        {
            try
            {
                Communication.Acesso objAcesso = new Communication.Acesso(this.Session);
                return objAcesso.VerificarAcesso(objRequest);
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
                return false;
            }
        }

        public bool validarLotesDigitacao(ModelCollection<Sinacor.UI.Bovespa.Ordens.Model.Ordem> lotes)
        {
            try
            {
                Communication.LoteDigitacao digitacao = new Communication.LoteDigitacao(this.Session);

                ModelCollection<Model.Parameter.ConsultarOrdemDistribuicaoOrdemLote> pRequest = new ModelCollection<ConsultarOrdemDistribuicaoOrdemLote>(); 
 
                foreach (Model.Ordem pItem  in  lotes) 
                {
                     ConsultarOrdemDistribuicaoOrdemLote item = new ConsultarOrdemDistribuicaoOrdemLote();
                     item.NumeroConjunto = Convert.ToInt32(pItem.NumeroConjunto); 
                     pRequest.Add(item);

                }
                return digitacao.ConsultarLoteDigitacaoMultiplo(pRequest); 

                
            }
            catch (Exception ex)
            {
                base.HandleException(ex);
                return false;
            }
        }
    }
}
